package com.atguigu.linkedlist;

import com.sun.org.apache.xalan.internal.xsltc.trax.XSLTCSource;

import java.util.Stack;

/**
 * @author 龍
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        System.out.println("开始测试");
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");
        //创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode4);
        singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.list();
        singleLinkedList.update(new HeroNode(2, "小卢", "小麒麟"));
        singleLinkedList.list();
        singleLinkedList.delete(2);
        singleLinkedList.list();
        System.out.println("面试一：获取头节点个数——————————————————————————");
        int length = SingleLinkedList.getLength(singleLinkedList.getHead());
        System.out.println("有效节点的个数为：" + length);
        System.out.println("面试二：倒数第index个节点为——————————————————————————");
        System.out.println("需要的节点为：" + SingleLinkedList.findLastIndexNode(singleLinkedList.getHead(), 1));
        System.out.println("面试三：链表反转——————————————————————————");
        SingleLinkedList.getReverser(singleLinkedList.getHead());
        singleLinkedList.list();
        System.out.println("面试四：链表逆序打印(未改变链表的结构)——————————————————————————");
        SingleLinkedList.reversePrint(singleLinkedList.getHead());
        System.out.println("-----------------------------------------");
        singleLinkedList.list();
        System.out.println("面试五：合并两个有序列表，合并之后链表依旧有序————————————————————————————————————");


    }
}

/**
 * 定义一个HeroNode，每一个HeroNode就是一个节点对象
 */
class HeroNode {
    /**
     * 定义一些必要的属性
     */
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;

    /**
     * 构造方法
     */
    HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

/**
 * 用来管理我们的英雄
 */
class SingleLinkedList {
    /**
     * 初始化头节点，不能动
     */
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    public void setHead(HeroNode head) {
        this.head = head;
    }

    /**
     * 添加节点到单项链表
     * 1 找到当前链表的最后节点
     * 2 将这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode) {
        //头节点不能动，因此需要一个辅助变量进行遍历（temp）
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果没有找到，指针下移(注意指针的移动和赋值之间的区别。)
            temp = temp.next;
        }
        //当退出循环的时候，temp指向链表的最后
        temp.next = heroNode;
    }

    /**
     * 按照编号的顺序添加节点
     * 如果这个排名已经存在，则添加失败
     */
    public void addByOrder(HeroNode heroNode) {
        //因为是单链表结构，我们寻找的temp是位于添加位置的上一个节点
        HeroNode temp = head;
        //添加的编号是否可以进行添加，true为已存在该编号，不可添加。
        boolean flag = false;
        while (true) {
            //说明temp已经到了链表的最后，说明可以添加
            if (temp.next == null) {
                break;
            }
            //此时就是要添加节点的位置
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                //编号存在，不可以进行添加
                flag = true;
                break;
            }
            //指针后移，遍历当前列表
            temp = temp.next;
        }
        if (flag) {
            System.out.println("准备插入的英雄的编号：" + heroNode.no + "，不能添加！！！");
        } else {
            //插入到列表的temp中去
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 显示链表：通过辅助变量进行遍历
     */
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空！！！");
            return;
        }
        //头节点不能动，因此需要一个辅助变量进行遍历（temp）
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果不为空，输出节点
            System.out.println(temp.next.toString());
            //需要后移，不然为死循环
            temp = temp.next;
        }
    }


    /**
     * 根据节点的编号对节点进行信息的修改
     */
    public void update(HeroNode newHeroNode) {
        //判断是否空
        if (head.next == null) {
            System.out.println("链表为空！！！");
            return;
        }
        //找到需要修改的节点，根据no
        HeroNode temp = head.next;
        //表示是否存在存在该节点，true代表该节点存在
        boolean flag = false;
        while (true) {
            //到了链表的结束
            if (temp == null) {
                break;
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            //辅助指针后移
            temp = temp.next;
        }
        if (flag) {
            //说明找到了节点
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.println("没有找到编号为：" + newHeroNode.no + "的英雄");
        }
    }

    /**
     *
     * 删除节点，因为是单链表结构，所以需要找到需要删除的节点的前一个节点。
     * @param no 需要删除的节点的编号。
     */

    public void delete(int no) {
        //判断是否空
        if (head.next == null) {
            System.out.println("链表为空！！！");
            return;
        }
        HeroNode temp = head;
        //判断是否存在一个指定节点
        boolean flag = false;
        while (true) {
            //遍历到了结束（特别注意，这里的判断顺序）
            if (temp.next == null) {
                break;
            }
            //注意删除操作的原理
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            //可以进行删除，当一个节点没有其他节点指向的时候，该节点会被垃圾回收机制删除
            temp.next = temp.next.next;
        } else {
            System.out.println("该编号：" + no + "不存在,无法删除！！！");
        }
    }

    /**
     * 面试1：获取链表的有效节点的个数(不计算头节点)
     *
     * @param head 链表的头节点
     * @return 返回有效节点的个数
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next;
        }
        return length;
    }

    /**
     * 获取倒数第k个节点的信息（新浪面试题）
     *
     * @param head 节点,倒数第index个
     * @return 该节点的信息
     * 思路：
     * 1 将链表从头到尾开始进行遍历，得到结点的个数size
     * 2 从链表的第一个开始遍历，遍历到size-k的位置
     * 3 找到为该节点，找不到为空
     */
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head.next == null) {
            return null;
        }
        //获取总结点的个数
        int size = SingleLinkedList.getLength(head);
        //对输入的index进行校验
        if (index <= 0 || index > size) {
            System.out.println("该节点找不到");
            return null;
        }
        //将指针cur移向第一个节点
        HeroNode cur = head.next;
        for (int i = 1; i <= size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /**
     * 单链表的反转（注意原链表会被破坏掉）
     */
    public static HeroNode getReverser(HeroNode head) {
        //当前链表为空或者只有一个节点的时候，无需进行反转
        if (head.next == null || head.next.next == null) {
            return null;
        }
        //新链表的头节点
        HeroNode reverserHead = new HeroNode(0, "", "");
        //定义一个辅助指针，帮助我们遍历原来的链表（代指当前的节点）
        HeroNode cur = head.next;
        //指向当前节点（cur）的下一个节点
        HeroNode next;
        //遍历原列表，每遍历一个节点就将其取出，并放在新的链表的最前端
        while (cur != null) {
            //保存下一个节点
            next = cur.next;
            //将cur的下一个节点指向新的链表的最前端
            cur.next = reverserHead.next;
            //将头指向当前的节点
            reverserHead.next = cur;
            //节点往下移动
            cur = next;
        }
        //head.next指向reverseHead.next
        head.next = reverserHead.next;
        return head;
    }

    /**
     * 从尾到头打印单链表
     * 1 将单链表进行翻转操作，然年再遍历即可，这样做的问题会破坏原来的单链表结构
     * 2 使用stack来进行操作(此次选用)
     */
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            System.out.println("链表为空，不能打印链表");
            return;
        }
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将节点压入栈中
        while (cur != null) {
            stack.push(cur);
            //节点后移
            cur = cur.next;
        }
        //将压入的节点全部弹出
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }
}
